home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / programm.ing / winlib.lzh / WINLIB / SLIDERS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1994-03-23  |  12.2 KB  |  363 lines
  1. /********************************************************************
  2.  *                                                                    *
  3.  *    Custom slider routine                                            *
  4.  *                                                                    *
  5.  *    Copyright (c) Clever Bits and Bitgate Software 1993 - 1994        *
  6.  *    All Rights Reserved.                                            *
  7.  *                                                                    *
  8.  *    Portions of this code are copyright (c) Tom Hudson 1986.        *
  9.  *                                                                    *
  10.  *    In order to protect Tom's copyright, all comments must remain    *
  11.  *    intact, unmodified.                                                *
  12.  *                                                                    *
  13.  *    Here are the slider routines, with a faster redraw, and a much    *
  14.  *    smarter routine.  These work better than his original routines. *
  15.  *                                                                    *
  16.  ********************************************************************
  17.  *                                                                    *
  18.  *    Update log:                                                        *
  19.  *                                                                    *
  20.  *    [3.2.86 - 6.4.86] Tom Hudson                                    *
  21.  *        not documented                                                *
  22.  *    [15.6.93 - 23.3.94] Ken Hollis                                    *
  23.  *        (global)            - optimized, modulized, and fixed bugs    *
  24.  *                            - fixed redrawing of slider track        *
  25.  *        DoHorizontalSlide    - optimized redraws (made w/deltas)        *
  26.  *                            - added check for 3D objects            *
  27.  *        DoVerticalSlide        - optimized redraws (made w/deltas)        *
  28.  *                            - added check for 3D objects            *
  29.  *                                                                    *
  30.  ********************************************************************/
  31.  
  32. #include <aes.h>
  33. #include <stdio.h>
  34.  
  35. #include "winlib.h"        /* WinLIB header file */
  36. #include "nkcc.h"        /* Normalized Keycodes header file */
  37.  
  38. #ifndef __SLIDERS__
  39. #define __SLIDERS__
  40. #endif
  41.  
  42. static int mousex,mousey,dum,moved;
  43. static int tbasex,tbasey,sbasex,sbasey;
  44.  
  45. /****************************************************/
  46. /* RESET HORIZONTAL SLIDER                          */
  47. /* -----------------------                          */
  48. /* Parameters:                                      */
  49. /* win     = window structure                       */
  50. /* number  = slider number (0-9)                    */
  51. /* maximum = maximum slider setting (0-maximum)     */
  52. /* initial = initial slider setting (0-maximum)     */
  53. /****************************************************/
  54.  
  55. void HorizontalSlideReset(WINDOW *win, int number, int maximum, int initial,
  56.                     int trackix, int slidix, int strtrack, int redraw)
  57. {
  58.     GRECT work;
  59.  
  60.     WWindGet(win, WF_WORKXYWH, &work.g_x, &work.g_y, &work.g_w, &work.g_h);
  61.  
  62.     win->slidmax[number]=maximum;
  63.     win->slidpos[number]=initial;
  64.     win->slidstep[number]=((long)(win->tree[trackix].ob_width-win->tree[slidix].ob_width)<<16)/(long)maximum;
  65.     win->slidacc[number]=win->slidstep[number]*(long)initial;
  66.     win->tree[slidix].ob_x=(int)(win->slidacc[number]>>16);
  67.  
  68.     if (strtrack)
  69.         ChangeObjectText(win->tree, strtrack, "  0", 3, TE_CNTR);
  70.  
  71.     if (redraw)
  72.         WRedrawWindow(win, win->tree[trackix].ob_x + win->size.g_x + work.g_x, win->tree[trackix].ob_y + win->size.g_y + work.g_y, win->tree[trackix].ob_width, win->tree[trackix].ob_height);
  73. }
  74.  
  75. /****************************************************/
  76. /* PROCESS HORIZONTAL SLIDER                        */
  77. /* -------------------------                        */
  78. /* Parameters:                                      */
  79. /* number  = slider number (0-9)                    */
  80. /* trackix = index of slider track                  */
  81. /* slidix  = index of slider                        */
  82. /* leftix  = index of left-move button              */
  83. /* rightix = index of right-move button             */
  84. /* whichix = index of item from form_do             */
  85. /* trakstep = # of steps for in-track click         */
  86. /****************************************************/
  87.  
  88. void DoHorizontalSlide(WINDOW *win, int number, int trackix,
  89.                 int slidix, int leftix, int rightix, int whichix,
  90.                 int trakstep, int strtrack)
  91. {
  92.     register int ix;
  93.     int tempx,temp,xx,yy,deltax,deltaw,origx,origy;
  94.     GRECT work;
  95.  
  96.     WWindGet(win, WF_WORKXYWH, &work.g_x, &work.g_y, &work.g_w, &work.g_h);
  97.  
  98.     moved=0;
  99.  
  100.     temp=win->slidpos[number];
  101.     graf_mkstate(&mousex,&mousey,&dum,&dum);
  102.  
  103.     objc_offset(win->tree,trackix,&xx,&yy);
  104.     objc_offset(win->tree,slidix,&origx,&origy);
  105.  
  106.     if(whichix==trackix) {
  107.         objc_offset(win->tree,slidix,&sbasex,&dum);
  108.  
  109.         if(mousex>sbasex) {
  110.             for(ix=0; ix<trakstep; ++ix) {
  111.                 if(win->slidpos[number]<win->slidmax[number]) {
  112.                     win->slidacc[number]+=win->slidstep[number];
  113.                     win->slidpos[number]++;
  114.                     moved=1;
  115.                 } else break;
  116.             }
  117.         } else {
  118.             for(ix=0; ix<trakstep; ++ix) {
  119.                 if(win->slidpos[number]>0) {
  120.                     win->slidacc[number]-=win->slidstep[number];
  121.                     win->slidpos[number]--;
  122.                     moved=1;
  123.                 } else break;
  124.             }
  125.         }
  126.     } else if(whichix==rightix) {
  127.         if(win->slidpos[number]<win->slidmax[number]) {
  128.             win->slidacc[number]+=win->slidstep[number];
  129.             win->slidpos[number]++;
  130.             moved=1;
  131.         }
  132.     } else if(whichix==leftix) {
  133.         if(win->slidpos[number]>0) {
  134.             win->slidacc[number]-=win->slidstep[number];
  135.             win->slidpos[number]--;
  136.             moved=1;
  137.         }
  138.     } else if(whichix==slidix) {
  139.         objc_offset(win->tree,slidix,&sbasex,&sbasey);
  140.         objc_offset(win->tree,trackix,&tbasex,&tbasey);
  141.  
  142.         tempx = (mousex-((win->tree[slidix].ob_width)/2)+3);
  143.  
  144.         if(tempx!=sbasex) {
  145.             win->slidacc[number]=(long)(tempx-tbasex)<<16;
  146.             win->slidpos[number]=(int)(win->slidacc[number]/win->slidstep[number]);
  147.             win->slidacc[number]=(long)win->slidpos[number]*win->slidstep[number];
  148.             moved=1;
  149.         }
  150.     }
  151.  
  152.     if(moved) {
  153.         if (win->slidacc[number]<0)
  154.             win->slidacc[number]=win->slidpos[number]=0;
  155.  
  156.         win->tree[slidix].ob_x=(int)(win->slidacc[number]>>16);
  157.  
  158.         if ((win->tree[slidix].ob_x+win->tree[slidix].ob_width)>win->tree[trackix].ob_width) {
  159.             win->tree[slidix].ob_x=(win->tree[trackix].ob_width-win->tree[slidix].ob_width);
  160.             win->slidpos[number]=(int)win->slidmax[number];
  161.             win->slidacc[number]=(long)(win->tree[trackix].ob_width-win->tree[slidix].ob_width)<<16;
  162.         }
  163.  
  164.         if (win->slidpos[number]<0)
  165.             win->slidpos[number]=0;
  166.  
  167.         if (win->slidpos[number]>win->slidmax[number])
  168.             win->slidpos[number]=win->slidmax[number];
  169.  
  170.         if (temp!=win->slidpos[number]) {
  171.             int newx,newy;
  172.             char *str;
  173.  
  174.             objc_offset(win->tree,slidix,&newx,&newy);
  175.  
  176.             deltax = origx - newx;
  177.  
  178.             if (origx>newx)
  179.                 deltaw = (origx + win->tree[slidix].ob_width) - (newx + win->tree[slidix].ob_width);
  180.             else
  181.                 deltaw = -((origx + win->tree[slidix].ob_width) - (newx + win->tree[slidix].ob_width));
  182.  
  183.             if (strtrack) {
  184.                 sprintf(str, "%3d", win->slidpos[number]);
  185.                 ChangeObjectText(win->tree, strtrack, str, 3, TE_CNTR);
  186.             }
  187.  
  188.             if ((deltaw != 0) || strtrack)
  189.                 if (win->tree[slidix].ob_state & DRAW3D)
  190.                     WRedrawWindowLevel(win, (origx>newx) ? newx : origx,
  191.                         yy,
  192.                         deltaw + win->tree[slidix].ob_width,
  193.                         win->tree[trackix].ob_height, trackix, 2);
  194.                 else
  195.                     WRedrawWindowLevel(win, (origx>newx) ? newx - 1 : origx - 1,
  196.                         yy,
  197.                         (deltaw + win->tree[slidix].ob_width) + 2,
  198.                         win->tree[trackix].ob_height, trackix, 1);
  199.         }
  200.     }
  201. }
  202.  
  203. /****************************************************/
  204. /* RESET VERTICAL SLIDER                            */
  205. /* ----------------------                           */
  206. /* Parameters:                                      */
  207. /* number  = slider number (0-9)                    */
  208. /* trackix = index of slider track                  */
  209. /* slidix  = index of slider                        */
  210. /* maximum = maximum slider setting (0-maximum)     */
  211. /* initial = initial slider setting (0-maximum)     */
  212. /****************************************************/
  213.  
  214. void VerticalSlideReset(WINDOW *win, int number, int maximum, int initial,
  215.                 int slidix, int trackix, int strtrack, int redraw)
  216. {
  217.     long work1=((long)(win->tree[trackix].ob_height-win->tree[slidix].ob_height)<<16);
  218.     GRECT work;
  219.  
  220.     WWindGet(win, WF_WORKXYWH, &work.g_x, &work.g_y, &work.g_w, &work.g_h);
  221.  
  222.     win->slidmax[number]=maximum;
  223.     win->slidpos[number]=initial;
  224.     win->slidstep[number]=work1/(long)maximum;
  225.     win->slidacc[number]=work1-win->slidstep[number]*(long)initial;
  226.     win->tree[slidix].ob_y=(int)(win->slidacc[number]>>16);
  227.  
  228.     if (strtrack)
  229.         ChangeObjectText(win->tree, strtrack, (char *) "  0", 3, TE_CNTR);
  230.  
  231.     if (redraw)
  232.         WRedrawWindow(win, win->tree[trackix].ob_x + win->size.g_x + work.g_x, win->tree[trackix].ob_y + win->size.g_y + work.g_y, win->tree[trackix].ob_width, win->tree[trackix].ob_height);
  233. }
  234.  
  235. /****************************************************/
  236. /* PROCESS VERTICAL SLIDER                          */
  237. /* -----------------------                          */
  238. /* Parameters:                                      */
  239. /* number  = slider number (0-9)                    */
  240. /* trackix = index of slider track                  */
  241. /* slidix  = index of slider                        */
  242. /* upix    = index of up-move button                */
  243. /* downix  = index of down-move button              */
  244. /* whichix = index of item from form_do             */
  245. /* trakstep = # of steps for in-track click         */
  246. /****************************************************/
  247.  
  248. void DoVerticalSlide(WINDOW *win, int number, int trackix,
  249.                 int slidix, int upix, int downix, int whichix,
  250.                 int trakstep, int strtrack)
  251. {
  252.     register int ix;
  253.     int tempy,temp, xx, yy, origx, origy, deltay, deltah;
  254.     GRECT work;
  255.  
  256.     WWindGet(win, WF_WORKXYWH, &work.g_x, &work.g_y, &work.g_w, &work.g_h);
  257.  
  258.     moved=0;
  259.  
  260.     temp=win->slidpos[number];
  261.     graf_mkstate(&mousex,&mousey,&dum,&dum);
  262.  
  263.     objc_offset(win->tree,trackix,&xx,&yy);
  264.     objc_offset(win->tree,slidix,&origx,&origy);
  265.  
  266.     if(whichix==trackix) {
  267.         objc_offset(win->tree,slidix,&dum,&sbasey);
  268.         if(mousey>sbasey) {
  269.             for(ix=0; ix<trakstep; ++ix) {
  270.                 if(win->slidpos[number]>0) {
  271.                     win->slidacc[number]+=win->slidstep[number];
  272.                     win->slidpos[number]--;
  273.                 }
  274.             }
  275.             moved=1;
  276.         } else {
  277.             for(ix=0; ix<trakstep; ++ix) {
  278.                 if(win->slidpos[number]<win->slidmax[number]) {
  279.                     win->slidacc[number]-=win->slidstep[number];
  280.                     win->slidpos[number]++;
  281.                 }
  282.             }
  283.             moved=1;
  284.         }
  285.     } else if(whichix==downix) {
  286.         if(win->slidpos[number]>0) {
  287.             win->slidacc[number]+=win->slidstep[number];
  288.             win->slidpos[number]--;
  289.             moved=1;
  290.         }
  291.     } else if(whichix==upix) {
  292.         if(win->slidpos[number]<win->slidmax[number]) {
  293.             win->slidacc[number]-=win->slidstep[number];
  294.             win->slidpos[number]++;
  295.             moved=1;
  296.         }
  297.     } else if(whichix==slidix) {
  298.         objc_offset(win->tree,slidix,&sbasex,&sbasey);
  299.         objc_offset(win->tree,trackix,&tbasex,&tbasey);
  300.  
  301.         tempy = (mousey-((win->tree[slidix].ob_height)/2)+1);
  302.  
  303.         if(tempy!=sbasey) {
  304.             win->slidacc[number]=(long)(tempy-tbasey)<<16;
  305.             win->slidpos[number]=win->slidmax[number]-(int)(win->slidacc[number]/win->slidstep[number]);
  306.             win->slidacc[number]=((long)(win->tree[trackix].ob_height-win->tree[slidix].ob_height)<<16)
  307.                             -(long)win->slidpos[number]*win->slidstep[number];
  308.             moved=1;
  309.         }
  310.     }
  311.  
  312.     if(moved) {
  313.         if (win->slidacc[number]<0) {
  314.             win->slidacc[number]=win->tree[slidix].ob_y<<16;
  315.             win->slidpos[number]=win->slidmax[number];
  316.         }
  317.  
  318.         win->tree[slidix].ob_y=(int)(win->slidacc[number]>>16);
  319.  
  320.         if ((win->tree[slidix].ob_y+win->tree[slidix].ob_height)>win->tree[trackix].ob_height) {
  321.             win->tree[slidix].ob_y=(win->tree[trackix].ob_height-win->tree[slidix].ob_height);
  322.             win->slidpos[number]=0;
  323.             win->slidacc[number]=(long)(win->tree[trackix].ob_height-win->tree[slidix].ob_height)<<16;
  324.         }
  325.  
  326.         if (win->slidpos[number]<0)
  327.             win->slidpos[number]=0;
  328.  
  329.         if (win->slidpos[number]>win->slidmax[number])
  330.             win->slidpos[number]=win->slidmax[number];
  331.  
  332.         if (temp!=win->slidpos[number]) {
  333.             int newx,newy;
  334.             char *str;
  335.  
  336.             objc_offset(win->tree,slidix,&newx,&newy);
  337.  
  338.             deltay = origy - newy;
  339.  
  340.             if (origy>newy)
  341.                 deltah = (origy + win->tree[slidix].ob_height) - (newy + win->tree[slidix].ob_height);
  342.             else
  343.                 deltah = -((origy + win->tree[slidix].ob_height) - (newy + win->tree[slidix].ob_height));
  344.  
  345.             if (strtrack) {
  346.                 sprintf(str, "%3d", win->slidpos[number]);
  347.                 ChangeObjectText(win->tree, strtrack, str, 3, TE_CNTR);
  348.             }
  349.  
  350.             if ((deltah != 0) || strtrack)
  351.                 if (win->tree[slidix].ob_state & DRAW3D)
  352.                     WRedrawWindowLevel(win, xx,
  353.                         (origy>newy) ? newy : origy,
  354.                         win->tree[slidix].ob_width,
  355.                         deltah + win->tree[slidix].ob_height, trackix, 2);
  356.                 else
  357.                     WRedrawWindowLevel(win, xx,
  358.                         (origy>newy) ? newy - 1 : origy - 1,
  359.                         win->tree[slidix].ob_width,
  360.                         (deltah + win->tree[slidix].ob_height) + 2, trackix, 1);
  361.         }
  362.     }
  363. }